debug.c

Go to the documentation of this file.

#include "derivative.h"
#include "HAL.h"
#include "CRC.h"
#include "FLASH.h"
#include "Freemaster.h"
//#include "Labview.h"
#include "DSPI.h"
#include "LIN_UART.h"
//#include "Utils.h"
#include "SIU.h"
#include "CGM.h"
#include "edma.h"
#include "MMA68xx.h"
#include "Compile_Options.h"
#include "ADC.h"
#include "UTILS.h"
#include "MailDelivery.h"
#include "MailScheduler.h"

#ifdef USE_DEMO_BOARD
#define LED1  ('D'), ((uint8_t)4u)
#define LED2  ('D'), ((uint8_t)5u)
#define LED3  ('D'), ((uint8_t)6u)
#define LED4  ('D'), ((uint8_t)7u)
#endif
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const uint8_t cu8ASCIIDelete[] = { 0x08u, 0xFFu, 0x08u };
const uint8_t gau8Welcome[] = "ARD2: Welcome. \n\r";
const uint8_t cu8NewLine[]   = "\n\r";
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
uint32_t gu32;
uint16_t gu16Counter;
uint8_t  gu8Counter;
uint32_t au32[2u];
uint8_t  gau8[9] = {
  '1', '2', '3', '4', '5', '6', '7', '8', '9'
};
/*
 ******************************************************************************
 * Freemaster stuff
 ******************************************************************************
 */
//#ifdef USE_FREEMASTER

/* Table with global variables */
FMSTR_TSA_TABLE_BEGIN(first_table)
    FMSTR_TSA_RO_VAR(gu16Counter,    FMSTR_TSA_UINT16)
FMSTR_TSA_TABLE_END()
FMSTR_TSA_TABLE_BEGIN(second_table)
    FMSTR_TSA_RO_VAR(gu8Counter,    FMSTR_TSA_UINT8)
FMSTR_TSA_TABLE_END()

/* Table with Tables */
FMSTR_TSA_TABLE_LIST_BEGIN()
    FMSTR_TSA_TABLE(first_table)
    FMSTR_TSA_TABLE(second_table)
FMSTR_TSA_TABLE_LIST_END()

FMSTR_APPCMD_RESULT myhandler(FMSTR_APPCMD_CODE /*nAppcmd*/, FMSTR_APPCMD_PDATA /*pData*/, FMSTR_SIZE /*nDataLen*/)
{
    // the return value is used as the application command result code
    return 0x10;    
}

//#endif
/*
 ******************************************************************************
 * main
 ******************************************************************************
 */


const uint32_t cu32ADCCh1Config = \
  (ADC_CH_ISR_EN | ADC_CH15 | (ADC_MODULE_1 << 8u));

int main(void) 
{
  ADCChConfig_t tMyADCConfig;
  TCD_t tMyDefaultConfig;
  uint8_t  u8Status;
  uint16_t au16Results[64];
  
  
  u8Status = u8fnMCUInit();
  
  /* Disable any existing conversions before we move on */
  u8Status = u8fnADCNormalConversionEnable(0, CLEAR);
  
  tMyADCConfig.P.ChDMAEn = TRUE;
  tMyADCConfig.P.ChIsrEn = CLEAR;
  tMyADCConfig.P.Channel = 12;
  tMyADCConfig.P.DMACh = 8;
  tMyADCConfig.P.Instance = 0;
  
  u8Status = u8fnADCChannelConfig((const ADCChConfig_t*)&tMyADCConfig, 
                                  (uint16_t*)&au16Results);
  
  /* Source Address will always be the ADC result */
  tMyDefaultConfig.P.SADDR = (((uint32_t)&ADC_0.CDR[12].R) + 2u);
  /* Destination address is our output vehicle (DSPI, for example) */
  tMyDefaultConfig.P.DADDR = (uint32_t)&au16Results;
  /* Modulus is 0 */
  tMyDefaultConfig.P.SMOD = CLEAR;
  tMyDefaultConfig.P.DMOD = CLEAR;
  /* We will transfer 32-bit words */
  tMyDefaultConfig.P.SSIZE = DMA_SIZE_16_BIT;
  tMyDefaultConfig.P.DSIZE = DMA_SIZE_16_BIT;
  tMyDefaultConfig.P.SOFF = 0u; /* Offset per minor loop (in bytes) */
  tMyDefaultConfig.P.DOFF = 2u; /* Destination offset per minor loop */
  tMyDefaultConfig.P.NBYTES = 2u; /* Inner loop transfer count (in bytes) */
  tMyDefaultConfig.P.SLAST = CLEAR;
  tMyDefaultConfig.P.CITERE_LINK = CLEAR;
  tMyDefaultConfig.P.BITERE_LINK = CLEAR;
  tMyDefaultConfig.P.CITER = 64; /* Times we'll execute our minor loop */
  tMyDefaultConfig.P.BITER = 64; /* Memory for the loop */
  tMyDefaultConfig.P.D_REQ = TRUE; /* Clear HW Start requests after major loop is done */
  
  tMyDefaultConfig.P.DLAST_SGA = -128; /* Last destination offset */
  tMyDefaultConfig.P.MAJORLINKCH = CLEAR;
  tMyDefaultConfig.P.BWC = DMA_BWC_4_CYCLE_STALL;
  tMyDefaultConfig.P.MAJORE_LINK = CLEAR; /* Disable ch2ch linking */
  tMyDefaultConfig.P.E_SG = CLEAR;
  
  tMyDefaultConfig.P.INT_HALF = CLEAR;
  tMyDefaultConfig.P.INT_MAJ = TRUE;
  tMyDefaultConfig.P.START = CLEAR;
  
  vfnDMAConfig(&tMyDefaultConfig, 8);
  
  /* Route it adequately */
  vfnDMAMUXInit((uint8_t)tMyADCConfig.P.DMACh, DMA_SOURCE_ADC0, CLEAR, TRUE);
  
  /* Enable HW signaling to channel 8 */
  EDMA.SERQR.R = (uint8_t)tMyADCConfig.P.DMACh;
  
  /* Now that the DMA and the ADC are configured, start ADC conversion */
  u8Status = u8fnADCNormalConversionEnable(0, TRUE);
  
  
  
  
  
#ifdef USE_FREEMASTER
   /************************* FREEMASTER *************************************/

   FMSTR_Init();
#endif
//  CRC32_1((uint8_t*)&gau8, 0x09, (uint32_t*)&gu32);
  for(;;)
  {
//    gu8Counter++;
//    gu16Counter++;
#ifdef USE_FREEMASTER
    /************************* FREEMASTER *************************************/
    FMSTR_Poll();
#endif
    
  }
  gu8Counter++;
  
}/* End MAIN */

#define cCrc16Polynomial   (0x1021)  // G(x) = x16 + x12 + x5 + 1
uint16_t u16fnCalcCrc16(uint8_t *ui8BasePtr, uint8_t ui8BufLen, uint16_t ui16CrcStart)
{
  uint8_t ui8CrcIdx;
  uint8_t ui8CrcLoop;
  uint8_t ui8CrcTdata;
  uint16_t ui16Crcword;
 
  ui16Crcword = ui16CrcStart;
 
  for (ui8CrcIdx = 0 ; ui8CrcIdx < ui8BufLen ; ui8CrcIdx++ )
  {
    ui8CrcTdata = *ui8BasePtr;      
    ui8BasePtr++;                  
 
    for (ui8CrcLoop = 0; ui8CrcLoop < 8;ui8CrcLoop++ )
    {
      if (((ui8CrcTdata ^ (uint8_t)(ui16Crcword >> 8)) & 0x80) != 0 )
      {
          ui16Crcword = ui16Crcword << 1;
          ui16Crcword = ui16Crcword ^ cCrc16Polynomial;
      }
      else
      {
          ui16Crcword = ui16Crcword << 1;
      }
      ui8CrcTdata = ui8CrcTdata << 1;
    } 
  } 
  return(ui16Crcword);
}

void vfnTestSystemForHWDebug(void)
{
  uint8_t au8Array[] = "SERIAL INTERFACE IS OK.";
  
  /* CAN */
  vfnToggleOutputPin('A', 1, TRUE);
  vfnToggleOutputPin('A', 1, CLEAR);
  vfnToggleOutputPin('A', 0, TRUE);
  vfnToggleOutputPin('A', 0, CLEAR);
  /* Reset gyro */
  vfnToggleOutputPin('C', 10, TRUE);
  vfnToggleOutputPin('C', 10, CLEAR);
  vfnToggleOutputPin('C', 9, TRUE);
  vfnToggleOutputPin('C', 9, CLEAR);
  /* LIN Enable */
  vfnToggleOutputPin('A', 10, TRUE);
  vfnToggleOutputPin('A', 10, CLEAR);
  /* LED */
  vfnToggleOutputPin('D', 0, TRUE);
  vfnToggleOutputPin('D', 0, CLEAR);
  vfnToggleOutputPin('D', 1, TRUE);
  vfnToggleOutputPin('D', 1, CLEAR);
  vfnToggleOutputPin('D', 2, TRUE);
  vfnToggleOutputPin('D', 2, CLEAR);
  vfnToggleOutputPin('D', 3, TRUE);
  vfnToggleOutputPin('D', 3, CLEAR);
  vfnToggleOutputPin('D', 4, TRUE);
  vfnToggleOutputPin('D', 4, CLEAR);
  
  (void)u8fnUARTWrite(1, (const uint8_t*)&au8Array, sizeof(au8Array));
  u8fnUARTRead(1, (const uint8_t*)&au8Array, 5);
  
  return;
}

/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */